=begin pod

=TITLE class Block

=SUBTITLE Code object with its own lexical scope

    class Block is Code { }

A C<Block> is a code object meant for small-scale code reuse.  A block is
created syntactically by a list of statements enclosed in curly braces.

Without an explicit signature or placeholder arguments, a block has C<$_>
as a positional argument

    my $block = { uc $_; };
    say $block.^name;           # OUTPUT: «Block␤»
    say $block('hello');        # OUTPUT: «HELLO␤»

A block can have a L<Signature|/type/Signature> between C<< -> >> or C<< <-> >>
and the block:

    my $add = -> $a, $b = 2 { $a + $b };
    say $add(40);               # OUTPUT: «42␤»

If the signature is introduced with C<< <-> >>, then the parameters are marked
as C<rw> by default:
X«|<->»

    my $swap = <-> $a, $b { ($a, $b) = ($b, $a) };
    my ($a, $b) = (2, 4);
    $swap($a, $b);
    say $a;                     # OUTPUT: «4␤»

Blocks that aren't of type C<Routine> (which is a subclass of C<Block>) are
transparent to L<return|/syntax/return>.

    sub f() {
        say <a b c>.map: { return 42 };
                       #   ^^^^^^   exits &f, not just the block
    }

The last statement is the implicit return value of the block.

    say {1}.(); # OUTPUT: «1␤»

Bare blocks in sink context are automatically executed:

    say 1;
    {
        say 2;                  # executed directly, not a Block object
    }
    say 3;

=end pod

# vim: expandtab softtabstop=4 shiftwidth=4 ft=perl6
